package com.fourWork;

import java.io.*;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 使用线程池将一个目录中的所有内容拷贝到另外一个目录中，包含子目录中的内容。
 */
public class ThreeTest implements Runnable {
    /**
     * 遍历目录中的内容
     */
    //用于保存新目录
    static List<String> listArrays = new ArrayList<>();
    //用于保存新文件
    static List<String> listArrays1 = new ArrayList<>();
    //用于保存旧目录
    static List<String> listCopy = null;
    //旧目录
    static String oldFile = null;
    //复制到的新目录
    static String newFile = null;

    /**
     * 声明查看文件夹的方法
     *
     * @param str
     */
    public void showFile(String str) {
        //声明File对象，用于获取文件或目录的特征信息
        File file = new File(str);
        //list 集合用于保存文件
        List<String> listFile = new ArrayList<>();
        //list 集合用于保存文件夹
        List<String> list = new ArrayList<>();
        //System.out.println(file);
        //File[] listFiles() 获取该目录下的所有内容
        File[] files = file.listFiles();
        for (File f : files) {
            //isFile() 判断是否为文件
            if (f.isFile()) {
                System.out.println("文件为" + f);
                //将文件保存到集合中
                listFile.add(String.valueOf(f));
            }
            //isDirectory() 判断是否为目录
            if (f.isDirectory()) {
                System.out.println("目录为" + f + "  路径为 " + f.getAbsolutePath());
                //将来文件夹保存到list集合中
                list.add(String.valueOf(f));
                //System.out.println("oldFile为"+oldFile);
                //System.out.println(String.valueOf(f).indexOf(oldFile));
                new ThreeTest().showFile(f.toString());
            }
            //return list;
        }
        //foreach遍历文件夹集合
        for (String s : list) {
            System.out.println("**********" + s);
            //s=s.replace();//lodFile = d:\a
            //将旧目录替换成新目录
            String replace = s.replace(oldFile/*"d:\\a"*/, newFile/*"d:\\A1"*/);
            listArrays.add(replace);
            //return list;
        }
        //foreach遍历文件集合
        for (String s : listFile) {
            System.out.println("------" + s);
            //s=s.replace();//lodFile = d:\a
            //将旧目录替换成新目录
            String replace = s.replace(oldFile/*"d:\\a"*/, newFile/*"d:\\A1"*/);
            listArrays1.add(replace);
            //return list;
        }
        //赋值
        listCopy = new ArrayList<>();
        for (String s : listFile) {
            System.out.println("------" + s);
            //s=s.replace();//lodFile = d:\a
            //将旧目录替换成新目录
            listCopy.add(s);
            //return list;
        }
        //return list;
    }

    /**
     * 声明创建文件的方法
     */
    public void createFile(List<String> list, List<String> listFile, String file) {
        System.out.println("进入createFile方法");
        //声明File对象并且赋值变量(file为新文件）
        File fileNewFile = new File(file);
        //如果新文件不存在则创建
        if (!fileNewFile.exists()) {
            fileNewFile.mkdirs();
        } else {
            System.out.println("根目录已存在");
        }
        //用于保存从旧文件中获取的目录
        List<File> list1 = new ArrayList<>();
        //用于保存从旧文件中获取的文件
        List<File> list2 = new ArrayList<>();
        //遍历目录，并且将旧文件中的目录新增到list1集合中用于保存
        for (String s : list) {
            System.out.println("》》》》》》" + s);
            list1.add(new File(String.valueOf(s)));
        }
        //判断是否有目录
        if (list1.size() >= 0) {
            System.out.println("没有目录");
        } else {
            //遍历目录集合，并且目录不存在时新增
            for (File f : list1) {
                System.out.println("++++++++++++" + f);
                if (!f.exists()) {
                    //新增目录
                    f.mkdirs();
                } else {
                    System.out.println(f.getName() + "目录已存在");
                }
            }
        }

        //遍历文件，并且将旧文件中的目录新增到list2集合中用于保存
        for (String s : listFile) {
            System.out.println(">>>>>>" + s);
            list2.add(new File(String.valueOf(s)));
        }
        if (list2.size() == 0) {
            System.out.println("没有文件");
        } else {
            //遍历文件集合，并且文件不存在时新增
            for (File f : list2) {
                System.out.println("==============" + f);
                if (!f.exists()) {
                    //新增文件
                    try {
                        f.createNewFile();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                } else {
                    System.out.println(f.getName() + "文件已存在");
                }
            }
        }

    }

    /**
     * 创建复制文件的方法
     */
    public void copyText(List<String> listOldFile, List<String> listNewFile) throws IOException {
        //用于保存从旧文件的文件文件名
        String[] listOld = new String[listOldFile.size()];
        //用于保存新文件的文件文件名
        String[] listNew = new String[listNewFile.size()];
        //遍历文件，并且将旧文件中的目录新增到listOld数组中用于保存
        for (int i = 0; i < listOldFile.size(); i++) {
            //System.out.println(">>>>>>" + s);
            listOld[i] = listOldFile.get(i);
        }
        //遍历文件，并且将新文件中的目录新增到listNew数组中用于保存
        for (int i = 0; i < listNewFile.size(); i++) {
            //System.out.println(">>>>>>" + s);
            listNew[i] = listNewFile.get(i);
        }
        //声明FileReader对象
        FileReader fr = null;
        //声明FileWriter对象
        FileWriter fw = null;

        for (int i = 0; i < listOld.length; i++) {
            int res = 0;
            System.out.println(res);
            //创建FileReader类型的对象与文件关联
            fr = new FileReader(listOld[i]);
            System.out.println(listOld[i].toString());
            // 创建FileWriter类型的对象与文件关联
            fw = new FileWriter(listNew[i]);
            System.out.println(listNew[i].toString());
            //System.out.println(fw);

            while ((res = fr.read()) != -1) {
                //写入单个字符
                fw.write(res);
                // System.out.println("拷贝"+res);
            }
            //释放资源
            fw.close();
            fr.close();

            System.out.println("----------------------");
        }
        System.out.println("拷贝成功");


    }

    @Override
    public void run() {
        //将一个目录中的所有内容拷贝到另外一个目录中，包含子目录中的内容
        File file = new File("d:/a");
        oldFile = "D:\\Download\\com\\mtwowork";
        newFile = "d:\\A5";
        //调用查询文件方法
        new ThreeTest().showFile(oldFile.toString());
//        List<String> list=new ArrayList<String>();
//        list.add("d:/a");
//        list.add("d:/a/b");
        //File file1=new File("d:/A1");
        //调用创建文件/文件夹的方法
        new ThreeTest().createFile(listArrays, listArrays1, newFile.toString());
        try {
            //调用复制文件的方法
            new ThreeTest().copyText(listCopy, listArrays1);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {

        /*
        static ExecutorService newCachedThreadPool() 创建一个可根据需要创建新线程的线程池
        static ExecutorService newFixedThreadPool(int nThreads) 创建一个可重用固定线程数的线程池
        static ExecutorService newSingleThreadExecutor() 创建一个只有一个线程的线程池


        其中ExecutorService接口是真正的线程池接口，主要实现类是ThreadPoolExecutor，常用方法如下:
        void execute(Runnable command) 执行任务和命令，通常用于执行Runnable
        Future submit(Callable task) 执行任务和命令，通常用于执行Callable
        void shutdown() 启动有序关闭
         */
        //1.创建线程池newFixedThreadPool(int nThreads) 创建一个可重用固定线程数的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        //2.向线程中布置任务
        executorService.execute(new ThreeTest());
        //3.关闭线程池
        executorService.shutdown();


    }


}
